In [46]:
from IPython.display import HTML
HTML('''<script>
code_show=true;
function code_toggle() {
if (code_show){
$('div.input').hide();
} else {
$('div.input').show();
}
code_show = !code_show
}
$( document ).ready(code_toggle);
</script>
The raw code for this IPython notebook is by default hidden for easier reading.
To toggle on/off the raw code, click <a href="javascript:code_toggle()">here</a>.''')
Out[46]:
In [47]:
#hide warnings
HTML('''<script>
code_show_err=true;
function code_toggle_err() {
if (code_show_err){
$('div.output_stderr').hide();
} else {
$('div.output_stderr').show();
}
code_show_err = !code_show_err
}
$( document ).ready(code_toggle_err);
</script>
To toggle on/off output errors, click <a href="javascript:code_toggle_err()">here</a>.''')
Out[47]:
In [48]:
print('Testing GAL4 lines upstream to 64A11-LexA')
print('Project A83, Daniel Bushey')
In [49]:
from IPython.core.display import display, HTML
display(HTML("<style>.container { width:100% !important; }</style>"))
In [50]:
import pandas as pd
import os
import sys
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
import ccModules as cc
import ccModules2 as cc2
from IPython.html.widgets import interact
import pandas as pd
from IPython.display import IFrame
from bokeh.palettes import Spectral4
from bokeh.plotting import figure, output_file, show
In [51]:
#load project specific parameters
from A83_init20190220 import *
In [59]:
#load data
#load pandas data frame
exceldata = pd.read_hdf(os.path.join(saveFig, 'Compiled_data.hdf5'), 'data')
#print(exceldata.shape)
#exceldata = exceldata[exceldata['Grade'] == 1]
In [60]:
exceldata
Out[60]:
In [53]:
print('Checking how many sessions included in the loaded data set:')
print(len(exceldata))
In [54]:
print('Stim Protocols')
exceldata['Stim Protocol'].unique()
Out[54]:
In [55]:
#combine stim protocols into one data frame
shortlist1 = exceldata[exceldata['Stim Protocol'] == 'stim30s06V']
shortlist2 = exceldata[exceldata['Stim Protocol'] == 'stimDur300at15']
for row, dseries in shortlist1.iterrows():
target = shortlist2[shortlist2['Sample Name'] == dseries['Sample Name']]
if len(target) >0:
shortlist1['timestamp'].loc[row] = np.concatenate((dseries['timestamp'], target['timestamp'].values[0] + dseries['timestamp'][-1]), axis=0)
shortlist1['voltage'].loc[row] = np.concatenate((dseries['voltage'], target['voltage'].values[0]), axis=0)
#no add the signals together
combined_intensity = {}
for ckey in dseries['intensity_data']['intensity']:
target_intensity = target['intensity_data'].iloc[0]
combined_intensity[ckey] = np.concatenate((dseries['intensity_data']['intensity'][ckey], target_intensity['intensity'][ckey]))
shortlist1['intensity_data'].loc[row]['intensity'] = combined_intensity
else: # select only those samples that have both stimulation periods
shortlist1.drop([row], inplace=True)
exceldata=shortlist1
In [56]:
#pull out roi data and add each roi as separate row
exceldata = cc2.pullIntensityData(exceldata)
In [57]:
#check parameters within data
parameters_to_compare = ['Cross']
print('These are the different conditions tested.')
for cp in parameters_to_compare:
print('Parameter:', cp)
print(exceldata[cp].unique())
In [58]:
#Get counts
print('Number of animals tested.')
groups = exceldata.groupby(['Cross', 'roi'])
groups['roi'].count()
Out[58]:
In [14]:
from bokeh.io import output_notebook, show
from bokeh.plotting import figure, output_file, show, ColumnDataSource
from bokeh.models import Range1d
In [15]:
output_notebook()
In [16]:
#create a dictionary holding data
raw_data={}
notroi = 'Background' #will look at all rois except background
for cgroup, frame1 in exceldata.groupby('Genotype'):
crois = frame1['roi'].unique()
crois = [ccroi for ccroi in crois if ccroi != notroi]
for croi in crois:
groupname = cgroup + '_' + croi
frame2 = frame1[frame1['roi'] == croi]
if len(frame2) != 0:
frame3 = cc2.intensityDataFrame(frame2)
raw_data[groupname] = frame3.subtractBackground(exceldata)
In [17]:
raw_data.keys()
Out[17]:
In [39]:
t = raw_data['SS33917_Region1']['intensity'].values
len(t[0])
plt.plot(t[0])
Out[39]:
In [18]:
volt = cc2.intensityDataFrame(exceldata).getVoltage()
timevolt = np.arange(0, len(volt))/100
plot=figure(y_range = (timevolt[0], timevolt[-1]), x_range = (0, 0.9), plot_width=600, plot_height=200)
plot=figure( plot_width=600, plot_height=200)
source = ColumnDataSource(data=dict(y=volt, x= timevolt ))
plot.line('x', 'y', source = source, line_width = 3, line_color ='red')
plot.x_range = Range1d(0, np.max(timevolt)*1.05)
plot.y_range = Range1d(0,np.max(volt)*1.05)
plot.xaxis.axis_label = 'Time (S)'
plot.yaxis.axis_label = 'Volt (V)'
#plot.line(timevolt,volt)
#output_file("StimProtocol.html", title = 'Stimulation Protocol')
show(plot)
In [19]:
from bokeh.models import LinearAxis, Range1d
from bokeh.palettes import Spectral5
from bokeh.models import Legend
In [20]:
colors = [(139, 69, 19), (154, 205, 50), (0, 238, 238), (123, 104, 238), (221, 160, 221)]
colors = dict(zip(raw_data.keys(), colors))
print(colors)
In [21]:
exceldata.columns
Out[21]:
In [22]:
source = ColumnDataSource(exceldata)
In [23]:
source.column_names
Out[23]:
In [24]:
p = figure(plot_width=800, plot_height=400, y_range=Range1d(min1, max1), x_range = Range1d(0, np.max(timeStamp)), x_axis_label = 'Time (S)', y_axis_label = 'Intensity - Background')
c = p.line('timestamp', 'intensity', source=source, line_width=2, line_color = (0, 0, 0))
show(p)
In [25]:
testframe = pd.DataFrame({'intensity' : [1,2,3,4], 'time' : [2,4,6,8]})
src = ColumnDataSource(testframe)
p = figure(plot_width=800, plot_height=400, y_range=Range1d(0, 10), x_range = Range1d(0, 10), x_axis_label = 'Time (S)', y_axis_label = 'Intensity - Background')
c = p.line('time', 'intensity', source=src, line_width=2, line_color = (0, 0, 0))
show(p)
In [41]:
plt.plot(timeStamp, np.mean(data, axis=0))
Out[41]:
In [45]:
#Intensity Data (subtract background plot)
#Each figure will plot a different gentoype
#black line is mean value
#light grey lines are individual data
timeStamp = cc2.intensityDataFrame(exceldata).getTimeStamp()
for ckey in list(raw_data.keys()):
#get the min and max range for the data
data = np.vstack(raw_data[ckey]['intensity'])
min1 = np.min(data)
max1 = np.max(data)
p = figure(plot_width=800, plot_height=400, y_range=Range1d(min1, max1), x_range = Range1d(0, np.max(timeStamp)), x_axis_label = 'Time (S)', y_axis_label = 'Intensity - Background')
#plot showing voltage
p.title.text = ckey
p.extra_y_ranges = {"foo": Range1d(start=-0, end=2)}
p.add_layout(LinearAxis(y_range_name='foo', axis_label = 'Volt (V)'), 'right')
c = p.line(timevolt, volt, y_range_name = 'foo', line_color = (255,0, 0), line_alpha=0.5, line_width =2)
#plot showing mean data results
legend_it = [('Voltage', [c])]
c = p.line(x=timeStamp, y=np.mean(data, axis=0), line_width=2, line_color = (0, 0, 0))
legend_it.append(('Mean', [c]))
for row in range(0,data.shape[0]):
c = p.line(x=timeStamp, y=data[row, :], line_width=2, line_color = (150, 150, 150), line_alpha = 0.5) #line_color = colors[cgroup])
legend_it.append((raw_data[ckey]['Sample Name'].iloc[row], [c]))
#p.sizing_mode = 'scale_width'
legend = Legend(items = legend_it, location=(0, 100))
legend.click_policy="hide"
p.add_layout(legend, 'right')
#p.x_range = Range1d(0, 450)
p.y_range = Range1d(min1, max1)
#output_file("Mean-RawIntensity.html", title = 'Stimulation Protocol')
#p.patch(timevolt2, volt2, y_range_name = 'foo')
show(p)
In [225]:
#Intensity Data (subtract background plot)
timeStamp = cc2.intensityDataFrame(exceldata).getTimeStamp()
#get the min and max range for the data
data = []
for ckey in raw_data.keys():
data.append( np.mean(np.vstack(raw_data[ckey]['intensity'].values), axis=0))
data=np.vstack(data)
data.shape
min1 = np.min(data)
max1 = np.max(data)
p = figure(plot_width=800, plot_height=400, y_range=(min1, max1), x_range = (0, len(timeStamp)), x_axis_label = 'Time (S)', y_axis_label = 'Intensity - Background')
#plot showing voltage
p.title.text = 'Click on legend entries to hide the corresponding lines'
p.extra_y_ranges = {"foo": Range1d(start=-0, end=1)}
p.add_layout(LinearAxis(y_range_name='foo', axis_label = 'Volt (V)'), 'right')
c = p.line(timevolt, volt, y_range_name = 'foo', line_color = (255,0, 0), line_alpha=0.5, line_width =2)
#plot showing mean data results
legend_it = [('Voltage', [c])]
for i, cgroup in enumerate(raw_data.keys()):
c = p.line(x=timeStamp, y=np.mean(np.vstack(raw_data[cgroup]['intensity'].values), axis=0), line_width=2, line_color = colors[cgroup])
legend_it.append((cgroup, [c]))
p.sizing_mode = 'scale_width'
legend = Legend(items = legend_it, location=(0, 200))
legend.click_policy="hide"
p.add_layout(legend, 'right')
#p.y_range.end = 400
#p.y_range.start =380
#output_file("Mean-RawIntensity.html", title = 'Stimulation Protocol')
#p.patch(timevolt2, volt2, y_range_name = 'foo')
show(p)
In [ ]:
def generateGroupNames(list1):
#list1 = list that is converted to string
for i, l in enumerate(list1):
if not isinstance(l, str):
list1[i] = str(l)
groupname = list1[0]
for cg in list1[1:]:
groupname = groupname + ' ' + cg
return groupname
In [ ]:
# getting the DeltaF/F responses for each time point then placing in a dictionary
deltaFF_data={}
parameters_to_compare = ['Genotype', 'Medium']
stimPeriods, stimoffPeriods = cc2.voltage(cc2.intensityDataFrame(exceldata).getVoltage()).getVoltageStopStarts()
prestim = 5 # time in s to include before stimulation
poststim = 20 # time after first stimulation to include
cgen= 'A74-1'
#add intensity data to dictionary
for cstimindex, cstim in enumerate(stimPeriods):
prestart = cstim - prestim
stop = stimoffPeriods[cstimindex] + poststim
cstimS = [str(cstim)]
for cgroup, frame in exceldata.groupby(parameters_to_compare):
frame = frame[frame['roi'].str.contains('gamma')]
dFF = cc2.intensityDataFrame(frame).getdFF(prestart, cstim, stop, exceldata, transgene[cgen]['response'])
cgroup2 = cstimS.copy()
cgroup2.extend(cgroup)
groupname2 = generateGroupNames(cgroup2)
deltaFF_data[groupname2] = dFF.deltaFF()
deltaFF_data[groupname2 + 'timeStamp'] = dFF.timeStamp
In [ ]:
#default stim period
for cstimindex, cstim in enumerate(stimPeriods):
#cstim = stimPeriods[1]
prestart = cstim - prestim
stop = stimoffPeriods[cstimindex] + poststim
cstim = [str(cstim)]
#get the min and max range for the data
data = []
for cgroup, frame in exceldata.groupby(parameters_to_compare):
cgroup2 = cstim.copy()
cgroup2.extend(cgroup)
groupname2 = generateGroupNames(cgroup2)
data.append( np.nanmean(deltaFF_data[groupname2], axis=0))
data=np.vstack(data)
data.shape
min1 = np.min(data)*1.05
max1 = np.max(data)*1.05
p = figure(plot_width=800, plot_height=400, y_range=(min1, max1), x_range = (prestart, stop), x_axis_label = 'Time (S)', y_axis_label = 'deltaF/F')
#plot showing voltage
p.title.text = 'Click on legend entries to hide the corresponding lines'
p.extra_y_ranges = {"foo": Range1d(start=-0, end=1)}
p.add_layout(LinearAxis(y_range_name='foo', axis_label = 'Volt (V)'), 'right')
c = p.line(timevolt, volt, y_range_name = 'foo', line_color = (255,0, 0), line_alpha=0.5, line_width =2)
legend_it = [('Voltage', [c])]
#add keys to dictionary that are the current drawings
for cgroup, frame in exceldata.groupby(parameters_to_compare):
cgroup = list(cgroup)
cgroupD = cgroup.copy()
cgroupD.extend(['Draw'])
cgroupD = generateGroupNames(cgroupD)
cgroup2 = cstim.copy()
cgroup2.extend(cgroup)
groupname2 = generateGroupNames(cgroup2)
deltaFF_data[cgroupD] = deltaFF_data[groupname2]
#plot showing mean data results
source = ColumnDataSource(data=deltaFF_data)
for cgroup, frame in exceldata.groupby(parameters_to_compare):
cgroupcolor = generateGroupNames(cgroup)
cgroupcolor = ' ' + cgroupcolor
cgroup2 = cstim.copy()
cgroup2.extend(cgroup)
groupname2 = generateGroupNames(cgroup2)
c = p.line(x=deltaFF_data[groupname2 + 'timeStamp'], y=np.nanmean(deltaFF_data[groupname2], axis=0), line_width=2, line_color = colors[cgroupcolor])
legend_it.append((cgroupcolor, [c]))
p.sizing_mode = 'scale_width'
legend = Legend(items = legend_it, location=(0, 200))
legend.click_policy="hide"
p.add_layout(legend, 'right')
#p.y_range.end = 400
#p.y_range.start =380
#output_file("Mean-RawIntensity.html", title = 'Stimulation Protocol')
#p.patch(timevolt2, volt2, y_range_name = 'foo')
show(p)
In [ ]:
In [ ]: